home *** CD-ROM | disk | FTP | other *** search
/ Greenhouse Effect Detection Expriment / NASA Greenhouse Effect Detection Expriment 1992 - Disc 2.iso / software / dos / cdf22pc / src / tools / calcstat.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-28  |  10.5 KB  |  458 lines
  1. /******************************************************************************
  2. *
  3. *  NSSDC/CDF                        Calculate statistics.
  4. *
  5. *  Version 2.0, 20-Feb-92, ST Systems (STX)
  6. *
  7. *  Modification history:
  8. *
  9. *   V1.0  29-Aug-91, J Love    Original version (for CDF V2.1).
  10. *   V2.0  20-Feb-92, J Love    IBM PC port.  Added fill value filtering.
  11. *
  12. ******************************************************************************/
  13.  
  14. #include <stdlib.h>
  15. #include <stdio.h>
  16.  
  17. #include "cdfdist.h"
  18. #include "cdfstats.h"
  19.  
  20. /******************************************************************************
  21. * MinMaxInit.
  22. ******************************************************************************/
  23.  
  24. void MinMaxInit () {
  25. void *_value_;
  26. Boolean _use_;
  27.  
  28. if (hyper)
  29.   _value_ = (Byte *) buffer + (numElemsV * ElemSize(dataTypeV) * valueN);
  30. else
  31.   _value_ = (Byte *) buffer;
  32.  
  33. if (filterFillsVar)
  34.   if (NE(_value_,fillval))
  35.     _use_ = TRUE;
  36.   else {
  37.     _use_ = FALSE;
  38.     fills++;
  39.   }
  40. else
  41.   _use_ = TRUE;
  42.  
  43. if (_use_) {
  44.   ASSIGN (min, _value_);
  45.   ASSIGN (max, _value_);
  46.   if (rangeCheckVar) {
  47.     if (LT(_value_,validmin))
  48.       low++;
  49.     else
  50.       if (GT(_value_,validmax))
  51.         high++;
  52.       else {
  53.         oneINrange = TRUE;
  54.         ASSIGN (minINrange, _value_);
  55.         ASSIGN (maxINrange, _value_);
  56.       }
  57.   }
  58.   minmaxInited = TRUE;
  59. }
  60. return;
  61. }
  62.  
  63. void MinMaxCheck () {
  64. void *_value_;
  65. Boolean _use_;
  66.  
  67. if (hyper)
  68.   _value_ = (Byte *) buffer + (ElemSize(dataTypeV) * numElemsV *  valueN);
  69. else
  70.   _value_ = (Byte *) buffer;
  71.  
  72. if (filterFillsVar)
  73.   if (NE(_value_,fillval))
  74.     _use_ = TRUE;
  75.   else {
  76.     _use_ = FALSE;
  77.     fills++;
  78.   }
  79. else
  80.   _use_ = TRUE;
  81.  
  82. if (_use_) {
  83.   if (LT(_value_,min))
  84.     ASSIGN (min, _value_);
  85.   else
  86.     if (GT(_value_,max))
  87.       ASSIGN (max, _value_);
  88.   if (rangeCheckVar) {
  89.     if (LT(_value_,validmin))
  90.       low++;
  91.     else
  92.       if (GT(_value_,validmax))
  93.         high++;
  94.       else
  95.         if (oneINrange) {
  96.           if (LT(_value_,minINrange))
  97.             ASSIGN (minINrange, _value_);
  98.           else
  99.             if (GT(_value_,maxINrange))
  100.               ASSIGN (maxINrange, _value_);
  101.         }
  102.         else {
  103.           oneINrange = TRUE;
  104.           ASSIGN (minINrange, _value_);
  105.           ASSIGN (maxINrange, _value_);
  106.         }
  107.   }
  108. }
  109. return;
  110. }
  111.  
  112. /******************************************************************************
  113. * Monotonic.
  114. ******************************************************************************/
  115.  
  116. void Monotonic () {
  117. void *_value_;
  118. Boolean _use_;
  119.  
  120. if (hyper)
  121.   _value_ = (Byte *) buffer + (numElemsV * ElemSize(dataTypeV) * valueN);
  122. else
  123.   _value_ = (Byte *) buffer;
  124.  
  125. if (filterFillsVar)
  126.   if (NE(_value_,fillval))
  127.     _use_ = TRUE;
  128.   else
  129.     _use_ = FALSE;
  130. else
  131.   _use_ = TRUE;
  132.  
  133. if (_use_)
  134.   if ( ! monoInited) {
  135.     ASSIGN (last, _value_);
  136.     state = _Init;
  137.     monoInited = TRUE;
  138.   }
  139.   else {
  140.     switch (state) {
  141.       case _Init:
  142.         if (EQ(_value_,last)) {
  143.           state = _Steady;
  144.           break;
  145.         }
  146.         if (LT(_value_,last)) {
  147.           state = _Decrease;
  148.           break;
  149.         }
  150.         if (GT(_value_,last)) {
  151.           state = _Increase;
  152.           break;
  153.         }
  154.         break;
  155.       case _Steady:
  156.         if (LT(_value_,last)) {
  157.           state = _noIncrease;
  158.           break;
  159.         }
  160.         if (GT(_value_,last)) {
  161.           state = _noDecrease;
  162.           break;
  163.         }
  164.         break;
  165.       case _Increase:
  166.         if (LT(_value_,last)) {
  167.           state = _False;
  168.           break;
  169.         }
  170.         if (EQ(_value_,last)) {
  171.           state = _noDecrease;
  172.           break;
  173.         }
  174.         break;
  175.       case _Decrease:
  176.         if (GT(_value_,last)) {
  177.           state = _False;
  178.           break;
  179.         }
  180.         if (EQ(_value_,last)) {
  181.           state = _noIncrease;
  182.           break;
  183.         }
  184.         break;
  185.       case _noIncrease:
  186.         if (GT(_value_,last)) {
  187.           state = _False;
  188.           break;
  189.         }
  190.         break;
  191.       case _noDecrease:
  192.         if (LT(_value_,last)) {
  193.           state = _False;
  194.           break;
  195.         }
  196.     }
  197.     ASSIGN (last, _value_);
  198.   }
  199. }
  200.  
  201. /******************************************************************************
  202. * Reads each record of a variable and calculates the statistics.
  203. ******************************************************************************/
  204.  
  205. void CALCstat (maxRec, NrecValues)
  206. long maxRec;
  207. long NrecValues;
  208. {
  209. long recN;
  210. CDFstatus status;
  211. char monotonic[80+1];
  212. long nBytes;
  213. static long indices[CDF_MAX_DIMS] = {0,0,0,0,0,0,0,0,0,0};
  214.  
  215. /******************************************************************************
  216. * Initialize for this variable.
  217. ******************************************************************************/
  218.  
  219. low = 0;
  220. high = 0;
  221. fills = 0;
  222. oneINrange = FALSE;
  223. minmaxInited = FALSE;
  224. monoInited = FALSE;
  225.  
  226. /******************************************************************************
  227. * Allocate memory.
  228. ******************************************************************************/
  229.  
  230. nBytes = ElemSize(dataTypeV) * numElemsV * NrecValues;
  231.  
  232. #if defined(__MSDOS__)
  233. if (nBytes > (long) 65535) {
  234.   hyper = FALSE;
  235.   MALLOC (buffer, ElemSize(dataTypeV) * numElemsV);
  236. }
  237. else {
  238. #endif
  239.   buffer = (void *) malloc (nBytes);
  240.   if (buffer == NULL) {    /* Not enough memory to use HyperGets - using SEQACC */
  241.     hyper = FALSE;
  242.     MALLOC (buffer, ElemSize(dataTypeV) * numElemsV);
  243.   }
  244.   else
  245.     hyper = TRUE;        /* Enough memory, use HyperGets. */
  246. #if defined(__MSDOS__)
  247. }
  248. #endif
  249.  
  250. MALLOC (min, ElemSize(dataTypeV) * numElemsV);
  251. MALLOC (max, ElemSize(dataTypeV) * numElemsV);
  252. MALLOC (last, ElemSize(dataTypeV) * numElemsV);
  253.  
  254. if (rangeCheckVar) {
  255.   MALLOC (minINrange, ElemSize(dataTypeV) * numElemsV);
  256.   MALLOC (maxINrange, ElemSize(dataTypeV) * numElemsV);
  257. }
  258.  
  259. if ( ! hyper) {
  260.   status = CDFlib (SELECT_, CDF_, id,
  261.                 VAR_SEQPOS_, (long) 0, indices,
  262.            NULL_);
  263.   CHECKstatus (status);
  264. }
  265.  
  266. /******************************************************************************
  267. * Read each record...
  268. ******************************************************************************/
  269.  
  270. for (recN = 0; recN <= maxRec; recN++) {
  271.    if (hyper) {
  272.      status = CDFlib (SELECT_, CDF_, id,
  273.                    CDF_RECNUMBER_, recN,
  274.               GET_, VAR_HYPERDATA_, buffer,
  275.               NULL_);
  276.      CHECKstatus (status);
  277.    }
  278.  
  279.    /***************************************************************************
  280.    * ...and calculate min/max and monotonicity for each value in each record.
  281.    ***************************************************************************/
  282.  
  283.    for (valueN = 0; valueN < NrecValues; valueN++) {
  284.       if ( ! hyper) {
  285.     status = CDFlib (SELECT_, CDF_, id,
  286.                   GET_, VAR_SEQDATA_, buffer,
  287.              NULL_);
  288.     CHECKstatus (status);
  289.       }
  290.  
  291.       if (minmaxInited)
  292.     MinMaxCheck ();
  293.       else
  294.     MinMaxInit ();
  295.  
  296.       if (checkMonotonicVar) Monotonic ();
  297.    }
  298. }
  299.  
  300. /**********************************************************************
  301. * display statistics
  302. **********************************************************************/
  303.  
  304. if (checkMonotonicVar)
  305.   if (monoInited)
  306.     switch (state) {
  307.       case _Init:
  308.         strcpy (monotonic, "Steady (one value)");
  309.         break;
  310.       case _Steady:
  311.         strcpy (monotonic, "Steady (all values the same)");
  312.         break;
  313.       case _Increase:
  314.         strcpy (monotonic, "Increase");
  315.         break;
  316.       case _Decrease:
  317.         strcpy (monotonic, "Decrease");
  318.         break;
  319.       case _noIncrease:
  320.         strcpy (monotonic, "noIncrease (some values the same)");
  321.         break;
  322.       case _noDecrease:
  323.         strcpy (monotonic, "noDecrease (some values the same)");
  324.         break;
  325.       case _False:
  326.         strcpy (monotonic, "False");
  327.         break;
  328.     }
  329.   else
  330.     strcpy (monotonic, "n/a (all fill values)");
  331. else
  332.   strcpy (monotonic, "n/a");
  333.  
  334. DISPstat (monotonic);
  335.  
  336. /******************************************************************************
  337. * Free memory used.
  338. ******************************************************************************/
  339.  
  340. free (buffer);
  341. free (min);
  342. free (max);
  343. free (last);
  344.  
  345. if (rangeCheckVar) {
  346.   free (minINrange);
  347.   free (maxINrange);
  348. }
  349.  
  350. return;
  351. }
  352.  
  353. /******************************************************************************
  354. * ASSIGN.
  355. ******************************************************************************/
  356.  
  357. void ASSIGN (dst, src)
  358. void *dst;
  359. void *src;
  360. {
  361. memmove (dst, src, numElemsV * ElemSize(dataTypeV));
  362. return;
  363. }
  364.  
  365. /******************************************************************************
  366. * EQ.
  367. ******************************************************************************/
  368.  
  369. Boolean EQ (a, b)
  370. void *a;
  371. void *b;
  372. {
  373. return (memcmp(a, b, numElemsV * ElemSize(dataTypeV)) == 0 ? TRUE : FALSE);
  374. }
  375.  
  376. /******************************************************************************
  377. * NE.
  378. ******************************************************************************/
  379.  
  380. Boolean NE (a, b)
  381. void *a;
  382. void *b;
  383. {
  384. return (memcmp(a, b, numElemsV * ElemSize(dataTypeV)) == 0 ? FALSE : TRUE);
  385. }
  386.  
  387. /******************************************************************************
  388. * LT.
  389. ******************************************************************************/
  390.  
  391. Boolean LT (a, b)
  392. void *a;
  393. void *b;
  394. {
  395. switch (dataTypeV) {
  396.   case CDF_BYTE:
  397.   case CDF_INT1:
  398.     return (*((Schar *) a) < *((Schar *) b));
  399.   case CDF_UINT1:
  400.     return (*((Uchar *) a) < *((Uchar *) b));
  401.   case CDF_INT2:
  402.     return (*((short *) a) < *((short *) b));
  403.   case CDF_UINT2:
  404.     return (*((unsigned short *) a) < *((unsigned short *) b));
  405.   case CDF_INT4:
  406.     return (*((long *) a) < *((long *) b));
  407.   case CDF_UINT4:
  408.     return (*((unsigned long *) a) < *((unsigned long *) b));
  409.   case CDF_REAL4:
  410.   case CDF_FLOAT:
  411.     return (*((float *) a) < *((float *) b));
  412.   case CDF_REAL8:
  413.   case CDF_DOUBLE:
  414.   case CDF_EPOCH:
  415.     return (*((double *) a) < *((double *) b));
  416.   case CDF_CHAR:
  417.   case CDF_UCHAR:
  418.     return (memcmp(a,b,numElemsV) < 0 ? TRUE : FALSE);
  419. }
  420. return FALSE;
  421. }
  422.  
  423. /******************************************************************************
  424. * GT.
  425. ******************************************************************************/
  426.  
  427. Boolean GT (a, b)
  428. void *a;
  429. void *b;
  430. {
  431. switch (dataTypeV) {
  432.   case CDF_BYTE:
  433.   case CDF_INT1:
  434.     return (*((Schar *) a) > *((Schar *) b));
  435.   case CDF_UINT1:
  436.     return (*((Uchar *) a) > *((Uchar *) b));
  437.   case CDF_INT2:
  438.     return (*((short *) a) > *((short *) b));
  439.   case CDF_UINT2:
  440.     return (*((unsigned short *) a) > *((unsigned short *) b));
  441.   case CDF_INT4:
  442.     return (*((long *) a) > *((long *) b));
  443.   case CDF_UINT4:
  444.     return (*((unsigned long *) a) > *((unsigned long *) b));
  445.   case CDF_REAL4:
  446.   case CDF_FLOAT:
  447.     return (*((float *) a) > *((float *) b));
  448.   case CDF_REAL8:
  449.   case CDF_DOUBLE:
  450.   case CDF_EPOCH:
  451.     return (*((double *) a) > *((double *) b));
  452.   case CDF_CHAR:
  453.   case CDF_UCHAR:
  454.     return (memcmp(a,b,numElemsV) > 0 ? TRUE : FALSE);
  455. }
  456. return FALSE;
  457. }
  458.